{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [],
   "source": [
    "\"\"\"\n",
    "Python code for Maximum likelihood esimation and Maximum A Posteriori (MAP) Parameter Estimation\n",
    "\"\"\"\n",
    "import matplotlib.patches as mpatches\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "import torch\n",
    "from torch.distributions import Normal"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us suppose that we know that the height of an adult resident in Statsville lies between 160 cm and 170 cm.\n",
    "We want to predict if this resident is female. For this purpose, we have collected a set of height samples from adult female residents in Statsville. This becomes our training data. From physical considerations, we can assume that the distribution of heights is Gaussian. Our goal is to estimate the parameters ($\\mu$, $\\sigma$) of this Gaussian. In this notebook, we will study two ways of doing this (1) Maximum Likelihood Estimation and (2) Maximum A Posteriori Estimation."
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Let us first create the dataset $X$ by sampling 10000 points from a Gaussian distribution with $\\mu$=152 and $\\sigma$=8. In real life scenarios, we do not know the mean and standard deviation of the true distribution. But for the sake of this example, let's assume that the mean height is 152cm and standard deviation is 50cm."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Dataset shape: torch.Size([10000, 1])\n"
     ]
    }
   ],
   "source": [
    "torch.random.manual_seed(42)\n",
    "num_samples = 10000\n",
    "mu = 152\n",
    "sigma = 8\n",
    "X = torch.normal(mu, sigma, size=(num_samples, 1))\n",
    "print('Dataset shape: {}'.format(X.shape))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maximum Likelihood Estimate (MLE)\n",
    "\n",
    "In MLE, we try to find the parameters that \"best explain\" our data. In other words, we try to find the parameters that maximize the joint likelihood of our training data instances. \n",
    "\n",
    "Let's say our model is parameterised by $\\theta$. The likelihood function $p(X|\\theta)$ shows how likely the sample distribution $X$ is for different values of $\\theta$. With MLE, our goal is to find the parameters $\\theta$ that maximise $p(X|\\theta)$. \n",
    "\n",
    "We can assume that our model parameterises a Gaussian distribution $N(\\mu, \\sigma)$\n",
    "The likelihood function can be written as \n",
    "    $$ p(X|\\theta) = N(X|\\mu,\\sigma) = \\prod_{i=1}^{n}N(x_i|\\mu,\\sigma) = \n",
    "    \\Bigl(\\frac{1}{2\\pi\\sigma^2}\\Bigl)^\\frac{N}{2}exp\\Bigl(\\frac{-1}{2\\sigma^2}\\sum_{i=1}^N(x_i - \\mu)^2\\Bigl) $$\n",
    "Maximising the likelihood function yields \n",
    "$$\\mu_{MLE} = \\frac{1}{N}\\sum_{i=1}^nx_i$$\n",
    "$$\\sigma_{MLE} = \\frac{1}{N}\\sum_{i=1}^n(x_i - \\mu)^2$$\n",
    "\n",
    "In practice, we maximise the logarithm of the likelihood because it makes for much easier calculations when dealing with exponential functions. Refer to the section 6.8 in the book for a detailed derivation\n",
    "\n",
    "Thus by computing the sample mean and the sample standard deviation, we can find the parameters of the best fit Gaussian for the dataset. Once we estimate the parameters, we can find out the probability that a sample lies in the range using the following formula\n",
    "$$ p(a < X <= b) = \\int_{a}^b p(X) dX $$"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Sample mean: 152.05149841308594\n",
      "Sample standard deviation: 8.035674095153809\n",
      "Prob: tensor([0.1485])\n"
     ]
    }
   ],
   "source": [
    "# Let us compute the mean and standard deviation of the sampled points.\n",
    "sample_mean = X.mean()\n",
    "sample_std = X.std()\n",
    "\n",
    "print('Sample mean: {}'.format(sample_mean))\n",
    "print('Sample standard deviation: {}'.format(sample_std))\n",
    "\n",
    "# As expected, the sample mean and sample standard deviation are close to the corresponding values \n",
    "# of the Normal distribution that the points were sampled from\n",
    "\n",
    "gaussian_mle = Normal(sample_mean, sample_std)\n",
    "\n",
    "# We want to find out the probability that a height between 160 and 170 belongs to an adult female resident\n",
    "a, b = torch.Tensor([160]), torch.Tensor([170])\n",
    "\n",
    "prob = gaussian_mle.cdf(b) - gaussian_mle.cdf(a)\n",
    "print('Prob: {}'.format(prob))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [],
   "source": [
    "a, b = torch.Tensor([160]), torch.Tensor([170])\n",
    "prob = gaussian_mle.cdf(b) - gaussian_mle.cdf(a)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### Maximum Likelihood Estimate using Gradient Descent\n",
    "Above, we were able to estimate the parameters using the closed form solution. Now, let us try to arrive at these parameters iteratively using gradient descent. In real-life scenarios, we don't use gradient descent because the closed form solution is available. But we discuss the gradient descent based approach to highlight some of the challenges.\n",
    "\n",
    "Our objective is to find the parameters $\\theta$ that maximise the likelihood function $p(X|\\theta)$. We choose to maximise the log of the likelihood function since it is more mathematically convenient. This can alternatively viewed as minimising the negative log-likelihood function.\n",
    "\n",
    "$$ -\\log p(X|\\theta) = \\frac{N}{2}\\log(2\\pi\\sigma^2) + \\frac{1}{2\\sigma^2}\\sum_{i=1}^n(x_i - \\mu)^2$$\n",
    "\n",
    "The optimisation process is as follows:\n",
    " 1. Initialise the model parameters, $\\mu$ and $\\sigma$ with random values\n",
    " 2. Compute the loss value (negative log-likelihood)\n",
    " 3. Find the gradients of the loss w.r.t the model parameters\n",
    " 4. Update the model parameters in the opposite direction of the gradient values\n",
    " 5. Repeat steps 1-4 until loss diminishes to a small value"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "from torch.autograd import Variable\n",
    "\n",
    "dtype = torch.FloatTensor\n",
    "\n",
    "# Negative log likelihood function defined above\n",
    "def neg_log_likelihood(X, mu, sigma):\n",
    "    N = X.shape[0]\n",
    "    X_minus_mu = torch.sub(X, mu)\n",
    "    return torch.mul(0.5 * N, torch.log(2 * np.pi * torch.pow(sigma, 2))) + \\\n",
    "           torch.div(torch.matmul(X_minus_mu.T, X_minus_mu), 2 * torch.pow(sigma, 2))\n",
    "\n",
    "# Gradient descent to estimate the parameters\n",
    "def optimise(X, mu, sigma, loss_fn, num_iters=100, lr = 0.001):\n",
    "    X = torch.Tensor(X) # Convert the data to a torch tensor\n",
    "\n",
    "    iters, losses, mus, sigmas = [], [], [], []\n",
    "    \n",
    "    for i in range(num_iters):\n",
    "        loss = loss_fn(X, mu, sigma)\n",
    " \n",
    "        if i % (num_iters / 10) == 0:\n",
    "            print('iter: {}, loss: {}, mu: {}, sigma: {}'.format(i, loss[0][0] / num_samples, \n",
    "                                                                 mu.data[0], sigma.data[0]))        \n",
    "            iters.append(i)\n",
    "            losses.append(loss[0][0] / num_samples)\n",
    "            mus.append(float(mu.data))\n",
    "            sigmas.append(float(sigma.data))\n",
    "            \n",
    "        # We don't explicitly compute the gradients ourselves. We rely on torch to automatically\n",
    "        # compute the gradients. The gradients are stored in <param>.grad. \n",
    "        loss.backward()\n",
    "\n",
    "        # We scale the gradients by the learning rate before update\n",
    "        mu.data -= lr * mu.grad\n",
    "        sigma.data -= lr * sigma.grad\n",
    "\n",
    "        # We zero out the gradients before every update. Otherwise gradients from previous iterations get accumulated\n",
    "        mu.grad.data.zero_()\n",
    "        sigma.grad.data.zero_()\n",
    "    return iters, losses, mus, sigmas"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [],
   "source": [
    "def plot_mle_fit(iters, mus, sigmas, expected_mu=152, expected_sigma=8, \n",
    "                 mu_text_y=160, sigma_text_y=100):\n",
    "    plt.figure(figsize=(4, 4))\n",
    "\n",
    "    ax1 = plt.subplot(2, 1, 1)\n",
    "    ax1.plot(iters, mus)\n",
    "    ax1.plot([iters[0], iters[-1]], [expected_mu, expected_mu], color='green')\n",
    "    ax1.text(iters[int(len(iters) / 2)], mu_text_y, r'Expected $\\mu={}$'.format(expected_mu))\n",
    "    ax1.set_xlabel('Iteration')\n",
    "    ax1.set_ylabel('Mean (cm)')\n",
    "    ax1.grid(True)\n",
    "    \n",
    "    ax2 = plt.subplot(2, 1, 2)\n",
    "    ax2.plot(iters, sigmas)\n",
    "    ax2.plot([iters[0], iters[-1]], [expected_sigma, expected_sigma], color='green')\n",
    "    ax2.text(iters[int(len(iters) / 2)], sigma_text_y, r'Expected $\\sigma={}$'.format(expected_sigma))\n",
    "    ax2.set_xlabel('Iteration')\n",
    "    ax2.set_ylabel('Sigma (cm)')\n",
    "    ax2.grid(True)\n",
    "\n",
    "    plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0, loss: 11441.484375, mu: 1.0, sigma: 1.0\n",
      "iter: 100, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n",
      "iter: 200, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n",
      "iter: 300, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n",
      "iter: 400, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n",
      "iter: 500, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n",
      "iter: 600, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n",
      "iter: 700, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n",
      "iter: 800, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n",
      "iter: 900, loss: 13.25956916809082, mu: 1511.5150146484375, sigma: 228802.3125\n"
     ]
    }
   ],
   "source": [
    "# We define our model params mu and sigma as torch Variables.\n",
    "# Note that requires_grad has been set to true - this tells PyTorch that gradients are \n",
    "# required to be computed for these variables. We randomly initialise both mu and sigma.\n",
    "\n",
    "mu = Variable(torch.Tensor([1]).type(dtype), requires_grad=True)\n",
    "sigma = Variable(torch.Tensor([1]).type(dtype), requires_grad=True)\n",
    "\n",
    "iters, losses, mus, sigmas = optimise(X, mu, sigma, neg_log_likelihood, num_iters=1000, lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_mle_fit(iters, mus, sigmas, mu_text_y=200, sigma_text_y=10000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "What just happened? The estimated mean and standard deviation are nowhere close to our expected values of 152 and 50, but are instead very large numbers.\n",
    "\n",
    "Let's try to tweak things a bit. We had randomly initialised mu and sigma with a value of 5. Now, let us initialise them somewhere in the neighborhood of our expected values. Let's say mu = 100 and sigma is 10."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0, loss: 17.091154098510742, mu: 100.0, sigma: 10.0\n",
      "iter: 50, loss: 4.972279071807861, mu: 118.44662475585938, sigma: 38.49309539794922\n",
      "iter: 100, loss: 4.697449684143066, mu: 129.03639221191406, sigma: 33.65633773803711\n",
      "iter: 150, loss: 4.295865535736084, mu: 139.3699951171875, sigma: 24.12708854675293\n",
      "iter: 200, loss: 3.5117764472961426, mu: 151.10028076171875, sigma: 8.470995903015137\n",
      "iter: 250, loss: 3.502779245376587, mu: 152.05128479003906, sigma: 8.035270690917969\n",
      "iter: 300, loss: 3.502779245376587, mu: 152.0514678955078, sigma: 8.035270690917969\n",
      "iter: 350, loss: 3.502779245376587, mu: 152.0514678955078, sigma: 8.035270690917969\n",
      "iter: 400, loss: 3.502779245376587, mu: 152.0514678955078, sigma: 8.035270690917969\n",
      "iter: 450, loss: 3.502779245376587, mu: 152.0514678955078, sigma: 8.035270690917969\n"
     ]
    }
   ],
   "source": [
    "# Let us initialise mu to 100 and sigma to 10\n",
    "mu = Variable(torch.Tensor([100]).type(dtype), requires_grad=True)\n",
    "sigma = Variable(torch.Tensor([10]).type(dtype), requires_grad=True)\n",
    "iters, losses, mus, sigmas = optimise(X, mu, sigma, neg_log_likelihood, num_iters=500)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "Our model has converged! The loss has decreased and the estimated $\\mu$ and $\\sigma$ are close to 152 and 50 respectively. The initial values of $\\mu$ and $\\sigma$ played a crucial role in helping the model converge. We were lucky this time because we knew what to expect for $\\mu$ and $\\sigma$. However, this is typically not the case in real world scenarios. Is there a better way to solve this problem? This is where Maximum A Posterior (MAP) estimation comes into play."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_mle_fit(iters, mus, sigmas, mu_text_y=145, sigma_text_y=10)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "## Maximum A Posteriori (MAP) Estimation\n",
    "\n",
    "Instead of maximizing $p(X|\\theta)$, we can directly maximize $p(\\theta|X)$ -> the probability of the parameters given the data instances.\n",
    "\n",
    "Using bayes theorem, $$p(\\theta|X) = \\frac{p(X|\\theta)p(\\theta)}{p(X)}$$\n",
    "\n",
    "Maximizing $p(\\theta|X)$ is equivalent to maximizing the numerator of the above expression because the denominator is independent of $\\theta$. $p(X|\\theta)$ is what we maximized in MLE. We need to estimate $p(\\theta)$, which is also called the prior probability. A popular approach is to say that we want the parameters to be as small as possible. Hence, we assume that $p(\\theta)$ is proportional to $e^{-\\theta^2}$. Refer to the chapter in the book for details. \n",
    "\n",
    "Maximizing $p(\\theta|X)$ is equivalent to minimizing $-\\log p(\\theta|X)$\n",
    "\n",
    "$$ -\\log p(\\theta|X) = -\\log p(X|\\theta) - \\log p(\\theta) = \\frac{N}{2}\\log(2\\pi\\sigma^2) + \\frac{1}{2\\sigma^2}\\sum_{i=1}^n(x_i - \\mu)^2 + \\mu^2 + \\sigma ^ 2 $$\n",
    "\n",
    "This is the same function as the negative log-likelihood discussed in MLE with two additional terms, $\\mu^2$ and $\\sigma^2$. They act as regularizers and prevent the parameters from exploding by penalizing large values of $\\mu$ and $\\sigma$."
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 11,
   "metadata": {},
   "outputs": [],
   "source": [
    "# Here we add two additional parameters to the loss function namely mu^2 and sigma^2\n",
    "# These parameter terms act as regularizers that penalise large values of mu and sigma.\n",
    "def neg_log_likelihood_regularized(X, mu, sigma, k=0.2):\n",
    "    \"\"\"\n",
    "    k is the regularization factor that controls the weight of the regularization loss\n",
    "    \"\"\"\n",
    "    N = X.shape[0]\n",
    "    X_minus_mu = torch.sub(X, mu)\n",
    "    loss_likelihood = torch.mul(0.5 * N, torch.log(2 * np.pi * torch.pow(sigma, 2))) + \\\n",
    "           torch.div(torch.matmul(X_minus_mu.T, X_minus_mu), 2 * torch.pow(sigma, 2))\n",
    "    loss_reg = k * (torch.pow(mu, 2) + torch.pow(sigma, 2))\n",
    "    return loss_likelihood + loss_reg "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "iter: 0, loss: 11441.484375, mu: 1.0, sigma: 1.0\n",
      "iter: 3000, loss: 95029.0625, mu: 455.33172607421875, sigma: 68924.90625\n",
      "iter: 6000, loss: 8626.0078125, mu: 137.10964965820312, sigma: 20754.244140625\n",
      "iter: 9000, loss: 790.3764038085938, mu: 41.306217193603516, sigma: 6247.732421875\n",
      "iter: 12000, loss: 78.79619598388672, mu: 12.747103691101074, sigma: 1875.296142578125\n",
      "iter: 15000, loss: 13.196134567260742, mu: 7.662846088409424, sigma: 544.9801025390625\n",
      "iter: 18000, loss: 6.360318183898926, mu: 55.84255599975586, sigma: 117.35157775878906\n",
      "iter: 21000, loss: 3.965273380279541, mu: 151.65988159179688, sigma: 8.03444766998291\n",
      "iter: 24000, loss: 3.965273380279541, mu: 151.65988159179688, sigma: 8.03444766998291\n",
      "iter: 27000, loss: 3.965273380279541, mu: 151.65988159179688, sigma: 8.03444766998291\n"
     ]
    }
   ],
   "source": [
    "# Let us run the optimiser with the regularise log likelihood function\n",
    "mu = Variable(torch.Tensor([1]).type(dtype), requires_grad=True)\n",
    "sigma = Variable(torch.Tensor([1]).type(dtype), requires_grad=True)\n",
    "iters, losses, mus, sigmas = optimise(X, mu, sigma, loss_fn=neg_log_likelihood_regularized, num_iters=30000, lr=0.001)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 13,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 400x400 with 2 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "plot_mle_fit(iters, mus, sigmas, mu_text_y=180, sigma_text_y=3000)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "As we can see, the model has converged and the estimated parameters are close to what we expected them to be."
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 4
}
